/****************************************************************
 * Fulguro
 * Copyright (C) 2004 Christophe Clienti
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 ***************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "flgrCoreIO.h"
#include "flgrCoreDispatch.h"
#include "flgrCoreArithDef.h"
#include "flgrCoreArithVector.h"

/*!
 * \addtogroup group_fulguro_core_vector
 * @{
 */


#define FLGR_MACRO_VECTOR_DIADIC_OP(dtype,arithop)	\
  int k;						\
  int spp = vctdest->spp;				\
  dtype *p1 = (dtype*) vct1->array;			\
  dtype *p2 = (dtype*) vct2->array;			\
  dtype *pdest = (dtype*) vctdest->array;		\
  dtype a1,a2;						\
							\
  FLGR_DECLARE_FUNCTION;				\
							\
  for(k=0 ; k<spp ; k++) {				\
    a1 = flgr_get_array_##dtype(p1,k);			\
    a2 = flgr_get_array_##dtype(p2,k);			\
    flgr_set_array_##dtype(pdest,k,arithop(a1,a2));	\
  }							\
  return


#define FLGR_MACRO_VECTOR_FUNC_OP(dtype,arithop)	\
  int k;						\
  int spp = vctdest->spp;				\
  dtype *p1 = (dtype*) vct1->array;			\
  fgFLOAT64 *p2 = (fgFLOAT64*) vct2->array;		\
  dtype *pdest = (dtype*) vctdest->array;		\
  dtype a1;						\
  fgFLOAT64 a2;						\
							\
  FLGR_DECLARE_FUNCTION;				\
							\
  for(k=0 ; k<spp ; k++) {				\
    a1 = flgr_get_array_##dtype(p1,k);			\
    a2 = flgr_get_array_fgFLOAT64(p2,k);		\
    flgr_set_array_##dtype(pdest,k,arithop(a1,a2));	\
  }							\
  return


#define FLGR_MACRO_VECTOR_MONOADIC_OP(dtype,arithop)	\
  int k;						\
  int spp = vctdest->spp;				\
  dtype *p1 = (dtype*) vct1->array;			\
  dtype *pdest = (dtype*) vctdest->array;		\
  dtype a1;						\
							\
  FLGR_DECLARE_FUNCTION;				\
							\
  for(k=0 ; k<spp ; k++) {				\
    a1 = flgr_get_array_##dtype(p1,k);			\
    flgr_set_array_##dtype(pdest,k,arithop(a1));	\
  }							\
  return



void flgr_vector_inf_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_inf_fgBIT);
}
void flgr_vector_inf_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_inf_fgUINT8);
}
void flgr_vector_inf_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_inf_fgUINT16);
}
void flgr_vector_inf_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_inf_fgUINT32);
}
void flgr_vector_inf_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_inf_fgUINT64);
}
void flgr_vector_inf_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_inf_fgINT8);
}
void flgr_vector_inf_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_inf_fgINT16);
}
void flgr_vector_inf_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_inf_fgINT32);
}
void flgr_vector_inf_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_inf_fgINT64);
}
void flgr_vector_inf_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_inf_fgFLOAT32);
}
void flgr_vector_inf_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_inf_fgFLOAT64);
}

////////////////////////////////////////////////////////////////////////////
/*! Compute inf  element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_inf(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_inf,vctdest,vct1,vct2);
}









void flgr_vector_sup_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_sup_fgBIT);
}
void flgr_vector_sup_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_sup_fgUINT8);
}
void flgr_vector_sup_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_sup_fgUINT16);
}
void flgr_vector_sup_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_sup_fgUINT32);
}
void flgr_vector_sup_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_sup_fgUINT64);
}
void flgr_vector_sup_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_sup_fgINT8);
}
void flgr_vector_sup_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_sup_fgINT16);
}
void flgr_vector_sup_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_sup_fgINT32);
}
void flgr_vector_sup_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_sup_fgINT64);
}
void flgr_vector_sup_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_sup_fgFLOAT32);
}
void flgr_vector_sup_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_sup_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute sup  element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_sup(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_sup,vctdest,vct1,vct2);
}





void flgr_vector_nand_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_nand_fgBIT);
}
void flgr_vector_nand_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_nand_fgUINT8);
}
void flgr_vector_nand_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_nand_fgUINT16);
}
void flgr_vector_nand_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_nand_fgUINT32);
}
void flgr_vector_nand_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_nand_fgUINT64);
}
void flgr_vector_nand_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_nand_fgINT8);
}
void flgr_vector_nand_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_nand_fgINT16);
}
void flgr_vector_nand_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_nand_fgINT32);
}
void flgr_vector_nand_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_nand_fgINT64);
}
void flgr_vector_nand_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_nand_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute nand  element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_nand(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_nand,vctdest,vct1,vct2);
}




void flgr_vector_and_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_and_fgBIT);
}
void flgr_vector_and_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_and_fgUINT8);
}
void flgr_vector_and_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_and_fgUINT16);
}
void flgr_vector_and_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_and_fgUINT32);
}
void flgr_vector_and_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_and_fgUINT64);
}
void flgr_vector_and_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_and_fgINT8);
}
void flgr_vector_and_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_and_fgINT16);
}
void flgr_vector_and_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_and_fgINT32);
}
void flgr_vector_and_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_and_fgINT64);
}
void flgr_vector_and_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_and_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute and  element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_and(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_and,vctdest,vct1,vct2);
}





void flgr_vector_or_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_or_fgBIT);
}
void flgr_vector_or_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_or_fgUINT8);
}
void flgr_vector_or_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_or_fgUINT16);
}
void flgr_vector_or_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_or_fgUINT32);
}
void flgr_vector_or_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_or_fgUINT64);
}
void flgr_vector_or_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_or_fgINT8);
}
void flgr_vector_or_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_or_fgINT16);
}
void flgr_vector_or_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_or_fgINT32);
}
void flgr_vector_or_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_or_fgINT64);
}
void flgr_vector_or_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_or_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute or element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_or(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_or,vctdest,vct1,vct2);
}


void flgr_vector_nor_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_nor_fgBIT);
}
void flgr_vector_nor_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_nor_fgUINT8);
}
void flgr_vector_nor_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_nor_fgUINT16);
}
void flgr_vector_nor_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_nor_fgUINT32);
}
void flgr_vector_nor_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_nor_fgUINT64);
}
void flgr_vector_nor_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_nor_fgINT8);
}
void flgr_vector_nor_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_nor_fgINT16);
}
void flgr_vector_nor_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_nor_fgINT32);
}
void flgr_vector_nor_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_nor_fgINT64);
}
void flgr_vector_nor_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_nor_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute nor element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_nor(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_nor,vctdest,vct1,vct2);
}




void flgr_vector_xor_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_xor_fgBIT);
}
void flgr_vector_xor_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_xor_fgUINT8);
}
void flgr_vector_xor_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_xor_fgUINT16);
}
void flgr_vector_xor_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_xor_fgUINT32);
}
void flgr_vector_xor_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_xor_fgUINT64);
}
void flgr_vector_xor_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_xor_fgINT8);
}
void flgr_vector_xor_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_xor_fgINT16);
}
void flgr_vector_xor_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_xor_fgINT32);
}
void flgr_vector_xor_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_xor_fgINT64);
}
void flgr_vector_xor_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_xor_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute xor element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_xor(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_xor,vctdest,vct1,vct2);
}




void flgr_vector_nxor_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_nxor_fgBIT);
}
void flgr_vector_nxor_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_nxor_fgUINT8);
}
void flgr_vector_nxor_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_nxor_fgUINT16);
}
void flgr_vector_nxor_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_nxor_fgUINT32);
}
void flgr_vector_nxor_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_nxor_fgUINT64);
}
void flgr_vector_nxor_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_nxor_fgINT8);
}
void flgr_vector_nxor_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_nxor_fgINT16);
}
void flgr_vector_nxor_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_nxor_fgINT32);
}
void flgr_vector_nxor_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_nxor_fgINT64);
}
void flgr_vector_nxor_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_nxor_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute nxor element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_nxor(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_nxor,vctdest,vct1,vct2);
}




void flgr_vector_add_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_or_fgBIT);
}
void flgr_vector_add_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_add_fgUINT8);
}
void flgr_vector_add_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_add_fgUINT16);
}
void flgr_vector_add_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_add_fgUINT32);
}
void flgr_vector_add_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_add_fgUINT64);
}
void flgr_vector_add_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_add_fgINT8);
}
void flgr_vector_add_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_add_fgINT16);
}
void flgr_vector_add_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_add_fgINT32);
}
void flgr_vector_add_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_add_fgINT64);
}
void flgr_vector_add_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_add_fgFLOAT32);
}
void flgr_vector_add_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_add_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute add element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_add(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_add,vctdest,vct1,vct2);
}






void flgr_vector_sub_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_sub_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_sub_a_b_fgUINT8);
}
void flgr_vector_sub_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_sub_a_b_fgUINT16);
}
void flgr_vector_sub_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_sub_a_b_fgUINT32);
}
void flgr_vector_sub_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_sub_a_b_fgUINT64);
}
void flgr_vector_sub_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_sub_a_b_fgINT8);
}
void flgr_vector_sub_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_sub_a_b_fgINT16);
}
void flgr_vector_sub_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_sub_a_b_fgINT32);
}
void flgr_vector_sub_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_sub_a_b_fgINT64);
}
void flgr_vector_sub_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_sub_a_b_fgFLOAT32);
}
void flgr_vector_sub_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_sub_a_b_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute sub element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_sub(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_sub,vctdest,vct1,vct2);
}





void flgr_vector_mult_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_and_fgBIT);  
}
void flgr_vector_mult_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_mult_fgUINT8);
}
void flgr_vector_mult_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_mult_fgUINT16);
}
void flgr_vector_mult_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_mult_fgUINT32);
}
void flgr_vector_mult_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_mult_fgUINT64);
}
void flgr_vector_mult_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_mult_fgINT8);
}
void flgr_vector_mult_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_mult_fgINT16);
}
void flgr_vector_mult_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_mult_fgINT32);
}
void flgr_vector_mult_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_mult_fgINT64);
}
void flgr_vector_mult_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_mult_fgFLOAT32);
}
void flgr_vector_mult_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_mult_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute mult element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_mult(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_mult,vctdest,vct1,vct2);
}






void flgr_vector_div_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_div_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_div_fgUINT8);
}
void flgr_vector_div_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_div_fgUINT16);
}
void flgr_vector_div_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_div_fgUINT32);
}
void flgr_vector_div_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_div_fgUINT64);
}
void flgr_vector_div_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_div_fgINT8);
}
void flgr_vector_div_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_div_fgINT16);
}
void flgr_vector_div_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_div_fgINT32);
}
void flgr_vector_div_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_div_fgINT64);
}
void flgr_vector_div_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_div_fgFLOAT32);
}
void flgr_vector_div_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_div_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute div element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_div(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_div,vctdest,vct1,vct2);
}




void flgr_vector_addsat_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_addsat_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_addsat_fgUINT8);
}
void flgr_vector_addsat_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_addsat_fgUINT16);
}
void flgr_vector_addsat_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_addsat_fgUINT32);
}
void flgr_vector_addsat_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_addsat_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_addsat_fgINT8);
}
void flgr_vector_addsat_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_addsat_fgINT16);
}
void flgr_vector_addsat_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_addsat_fgINT32);
}
void flgr_vector_addsat_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_addsat_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_addsat_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute addsat element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_addsat(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_addsat,vctdest,vct1,vct2);
}







void flgr_vector_subsat_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_subsat_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_subsat_fgUINT8);
}
void flgr_vector_subsat_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_subsat_fgUINT16);
}
void flgr_vector_subsat_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_subsat_fgUINT32);
}
void flgr_vector_subsat_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_subsat_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_subsat_fgINT8);
}
void flgr_vector_subsat_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_subsat_fgINT16);
}
void flgr_vector_subsat_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_subsat_fgINT32);
}
void flgr_vector_subsat_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_subsat_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_subsat_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute subsat element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_subsat(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_subsat,vctdest,vct1,vct2);
}





void flgr_vector_multsat_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_multsat_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_multsat_fgUINT8);
}
void flgr_vector_multsat_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_multsat_fgUINT16);
}
void flgr_vector_multsat_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_multsat_fgUINT32);
}
void flgr_vector_multsat_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_multsat_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_multsat_fgINT8);
}
void flgr_vector_multsat_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_multsat_fgINT16);
}
void flgr_vector_multsat_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_multsat_fgINT32);
}
void flgr_vector_multsat_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_multsat_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_multsat_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute multsat element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_multsat(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_multsat,vctdest,vct1,vct2);
}






void flgr_vector_atan2_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_atan2_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_atan2_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_atan2_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_atan2_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_atan2_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_INT8);  
}
void flgr_vector_atan2_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_INT16);  
}
void flgr_vector_atan2_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_INT32);  
}
void flgr_vector_atan2_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_atan2_fgFLOAT32(FLGR_Vector *vctdest,FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_atan2_fgFLOAT32);
}
void flgr_vector_atan2_fgFLOAT64(FLGR_Vector *vctdest,FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_atan2_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute atan2 element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_atan2(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_atan2,vctdest,vct1,vct2);
}







void flgr_vector_logb_fgBIT(FLGR_Vector *vctdest,FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_logb_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgUINT8,flgr_defop_logb_fgUINT8);
}
void flgr_vector_logb_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgUINT16,flgr_defop_logb_fgUINT16);
}
void flgr_vector_logb_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgUINT32,flgr_defop_logb_fgUINT32);
}
void flgr_vector_logb_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgUINT64,flgr_defop_logb_fgUINT64);
}
void flgr_vector_logb_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgINT8,flgr_defop_logb_fgINT8);
}
void flgr_vector_logb_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgINT16,flgr_defop_logb_fgINT16);
}
void flgr_vector_logb_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgINT32,flgr_defop_logb_fgINT32);
}
void flgr_vector_logb_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgINT64,flgr_defop_logb_fgINT64);
}
void flgr_vector_logb_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgFLOAT32,flgr_defop_logb_fgFLOAT32);
}
void flgr_vector_logb_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgFLOAT64,flgr_defop_logb_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute logb element by element over two FLGR_Vector
 *
 *  Each Element of vct2 represent the base for the corresponding element of vct1
 *
 *  vctdest[k] = logb(vct1[k], vct2[k])
 *
 *
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_logb(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_logb,vctdest,vct1,vct2);
}





void flgr_vector_powb_fgBIT(FLGR_Vector *vctdest,FLGR_Vector *vct1,FLGR_Vector *vct2) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_powb_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgUINT8,flgr_defop_powb_fgUINT8);
}
void flgr_vector_powb_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgUINT16,flgr_defop_powb_fgUINT16);
}
void flgr_vector_powb_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgUINT32,flgr_defop_powb_fgUINT32);
}
void flgr_vector_powb_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgUINT64,flgr_defop_powb_fgUINT64);
}
void flgr_vector_powb_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgINT8,flgr_defop_powb_fgINT8);
}
void flgr_vector_powb_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgINT16,flgr_defop_powb_fgINT16);
}
void flgr_vector_powb_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgINT32,flgr_defop_powb_fgINT32);
}
void flgr_vector_powb_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgINT64,flgr_defop_powb_fgINT64);
}
void flgr_vector_powb_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgFLOAT32,flgr_defop_powb_fgFLOAT32);
}
void flgr_vector_powb_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1,  FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_FUNC_OP(fgFLOAT64,flgr_defop_powb_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute powb element by element over two FLGR_Vector
 *
 *  Each Element of vct2 represent the power for the corresponding element of vct1
 *
 *  vctdest[k] = powb(vct1[k], vct2[k])
 *
 *
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_powb(FLGR_Vector *vctdest, FLGR_Vector *vct1,FLGR_Vector *vct2) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_powb,vctdest,vct1,vct2);
}








void flgr_vector_not_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgBIT,flgr_defop_not_fgBIT);
}
void flgr_vector_not_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgUINT8,flgr_defop_not_fgUINT8);
}
void flgr_vector_not_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgUINT16,flgr_defop_not_fgUINT16);
}
void flgr_vector_not_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgUINT32,flgr_defop_not_fgUINT32);
}
void flgr_vector_not_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgUINT64,flgr_defop_not_fgUINT64);
}
void flgr_vector_not_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT8,flgr_defop_not_fgINT8);
}
void flgr_vector_not_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT16,flgr_defop_not_fgINT16);
}
void flgr_vector_not_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT32,flgr_defop_not_fgINT32);
}
void flgr_vector_not_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT64,flgr_defop_not_fgINT64);
}
void flgr_vector_not_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_FLOAT32);  
}
void flgr_vector_not_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_FLOAT64);  
}
////////////////////////////////////////////////////////////////////////////
/*! Compute not element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_not(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_not,vctdest,vct1);
}





void flgr_vector_invert_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgBIT,flgr_defop_invert_fgBIT);
}
void flgr_vector_invert_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgUINT8,flgr_defop_invert_fgUINT8);
}
void flgr_vector_invert_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgUINT16,flgr_defop_invert_fgUINT16);
}
void flgr_vector_invert_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgUINT32,flgr_defop_invert_fgUINT32);
}
void flgr_vector_invert_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgUINT64,flgr_defop_invert_fgUINT64);
}
void flgr_vector_invert_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT8,flgr_defop_invert_fgINT8);
}
void flgr_vector_invert_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT16,flgr_defop_invert_fgINT16);
}
void flgr_vector_invert_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT32,flgr_defop_invert_fgINT32);
}
void flgr_vector_invert_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT64,flgr_defop_invert_fgINT64);
}
void flgr_vector_invert_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_invert_fgFLOAT32);
}
void flgr_vector_invert_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_invert_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute invert (a better name could be opposite)  element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_invert(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_invert,vctdest,vct1);
}





void flgr_vector_abs_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_abs_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_abs_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_abs_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_abs_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_abs_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT8,flgr_defop_abs_fgINT8);
}
void flgr_vector_abs_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT16,flgr_defop_abs_fgINT16);
}
void flgr_vector_abs_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT32,flgr_defop_abs_fgINT32);
}
void flgr_vector_abs_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgINT64,flgr_defop_abs_fgINT64);
}
void flgr_vector_abs_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_abs_fgFLOAT32);
}
void flgr_vector_abs_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_abs_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute abs element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_abs(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_abs,vctdest,vct1);
}




void flgr_vector_cos_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_cos_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_cos_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_cos_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_cos_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_cos_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT8);  
}
void flgr_vector_cos_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT16);  
}
void flgr_vector_cos_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT32);  
}
void flgr_vector_cos_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_cos_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_cos_fgFLOAT32);
}
void flgr_vector_cos_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_cos_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute cos element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_cos(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_cos,vctdest,vct1);
}




void flgr_vector_sin_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_sin_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_sin_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_sin_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_sin_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_sin_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT8);  
}
void flgr_vector_sin_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT16);  
}
void flgr_vector_sin_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT32);  
}
void flgr_vector_sin_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_sin_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sin_fgFLOAT32);
}
void flgr_vector_sin_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_sin_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute sin element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_sin(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_sin,vctdest,vct1);
}




void flgr_vector_tan_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_tan_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_tan_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_tan_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_tan_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_tan_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT8);  
}
void flgr_vector_tan_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT16);  
}
void flgr_vector_tan_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT32);  
}
void flgr_vector_tan_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_tan_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_tan_fgFLOAT32);
}
void flgr_vector_tan_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_tan_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute tan element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_tan(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_tan,vctdest,vct1);
}



void flgr_vector_acos_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_acos_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_acos_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_acos_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_acos_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_acos_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT8);  
}
void flgr_vector_acos_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT16);  
}
void flgr_vector_acos_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT32);  
}
void flgr_vector_acos_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_acos_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_acos_fgFLOAT32);
}
void flgr_vector_acos_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_acos_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute acos element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_acos(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_acos,vctdest,vct1);
}






void flgr_vector_asin_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_asin_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_asin_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_asin_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_asin_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_asin_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT8);  
}
void flgr_vector_asin_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT16);  
}
void flgr_vector_asin_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT32);  
}
void flgr_vector_asin_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_asin_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_asin_fgFLOAT32);
}
void flgr_vector_asin_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_asin_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute asin element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_asin(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_asin,vctdest,vct1);
}





void flgr_vector_atan_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_atan_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_atan_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_atan_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_atan_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_atan_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT8);  
}
void flgr_vector_atan_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT16);  
}
void flgr_vector_atan_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT32);  
}
void flgr_vector_atan_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_atan_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_atan_fgFLOAT32);
}
void flgr_vector_atan_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_atan_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute atan element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_atan(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;
    
  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_atan,vctdest,vct1);
}




void flgr_vector_floor_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_floor_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_floor_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_floor_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_floor_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_floor_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT8);  
}
void flgr_vector_floor_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT16);  
}
void flgr_vector_floor_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT32);  
}
void flgr_vector_floor_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_floor_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_floor_fgFLOAT32);
}
void flgr_vector_floor_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_floor_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute floor element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_floor(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_floor,vctdest,vct1);
}






void flgr_vector_ceil_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_ceil_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT8);  
}
void flgr_vector_ceil_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT16);  
}
void flgr_vector_ceil_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT32);  
}
void flgr_vector_ceil_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_UINT64);  
}
void flgr_vector_ceil_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT8);  
}
void flgr_vector_ceil_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT16);  
}
void flgr_vector_ceil_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT32);  
}
void flgr_vector_ceil_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_INT64);  
}
void flgr_vector_ceil_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_ceil_fgFLOAT32);
}
void flgr_vector_ceil_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_ceil_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute ceil element by element over two FLGR_Vector
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_ceil(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_ceil,vctdest,vct1);
}



void flgr_vector_square_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_square_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_square_fgUINT8);
}
void flgr_vector_square_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_square_fgUINT16);
}
void flgr_vector_square_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_square_fgUINT32);
}
void flgr_vector_square_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_square_fgUINT64);
}
void flgr_vector_square_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_square_fgINT8);
}
void flgr_vector_square_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_square_fgINT16);
}
void flgr_vector_square_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_square_fgINT32);
}
void flgr_vector_square_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_square_fgINT64);
}
void flgr_vector_square_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_square_fgFLOAT32);
}
void flgr_vector_square_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_square_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute square element by element
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_square(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_square,vctdest,vct1);
}




void flgr_vector_sqrt_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  flgr_no_define_type_function(FLGR_BIT);  
}
void flgr_vector_sqrt_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sqrt_fgUINT8);
}
void flgr_vector_sqrt_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sqrt_fgUINT16);
}
void flgr_vector_sqrt_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sqrt_fgUINT32);
}
void flgr_vector_sqrt_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sqrt_fgUINT64);
}
void flgr_vector_sqrt_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sqrt_fgINT8);
}
void flgr_vector_sqrt_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sqrt_fgINT16);
}
void flgr_vector_sqrt_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sqrt_fgINT32);
}
void flgr_vector_sqrt_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sqrt_fgINT64);
}
void flgr_vector_sqrt_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT32,flgr_defop_sqrt_fgFLOAT32);
}
void flgr_vector_sqrt_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_MONOADIC_OP(fgFLOAT64,flgr_defop_sqrt_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compute sqrt element by element
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_sqrt(FLGR_Vector *vctdest, FLGR_Vector *vct1) {
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct1);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type,flgr_vector_sqrt,vctdest,vct1);
}








void flgr_vector_cmp_ne_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_ne_fgBIT);
}
void flgr_vector_cmp_ne_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_ne_fgUINT8);
}
void flgr_vector_cmp_ne_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_ne_fgUINT16);
}
void flgr_vector_cmp_ne_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_ne_fgUINT32);
}
void flgr_vector_cmp_ne_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_ne_fgUINT64);
}
void flgr_vector_cmp_ne_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_ne_fgINT8);
}
void flgr_vector_cmp_ne_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_ne_fgINT16);
}
void flgr_vector_cmp_ne_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_ne_fgINT32);
}
void flgr_vector_cmp_ne_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_ne_fgINT64);
}
void flgr_vector_cmp_ne_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_ne_fgFLOAT32);
}
void flgr_vector_cmp_ne_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_ne_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compare two vectors and store results in a vector
 *
 *  dest[k] = (vct1[k] != vct2[k]) ? MAX_TYPE : 0
 *
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_cmp_ne(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type, flgr_vector_cmp_ne, vctdest, vct1, vct2);
}






void flgr_vector_cmp_eq_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_eq_fgBIT);
}
void flgr_vector_cmp_eq_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_eq_fgUINT8);
}
void flgr_vector_cmp_eq_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_eq_fgUINT16);
}
void flgr_vector_cmp_eq_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_eq_fgUINT32);
}
void flgr_vector_cmp_eq_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_eq_fgUINT64);
}
void flgr_vector_cmp_eq_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_eq_fgINT8);
}
void flgr_vector_cmp_eq_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_eq_fgINT16);
}
void flgr_vector_cmp_eq_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_eq_fgINT32);
}
void flgr_vector_cmp_eq_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_eq_fgINT64);
}
void flgr_vector_cmp_eq_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_eq_fgFLOAT32);
}
void flgr_vector_cmp_eq_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_eq_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compare two vectors and store results in a vector
 *
 *  dest[k] = (vct1[k] == vct2[k]) ? MAX_TYPE : 0
 *
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_cmp_eq(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type, flgr_vector_cmp_eq, vctdest, vct1, vct2);
}






void flgr_vector_cmp_gt_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_gt_fgBIT);
}
void flgr_vector_cmp_gt_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_gt_fgUINT8);
}
void flgr_vector_cmp_gt_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_gt_fgUINT16);
}
void flgr_vector_cmp_gt_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_gt_fgUINT32);
}
void flgr_vector_cmp_gt_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_gt_fgUINT64);
}
void flgr_vector_cmp_gt_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_gt_fgINT8);
}
void flgr_vector_cmp_gt_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_gt_fgINT16);
}
void flgr_vector_cmp_gt_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_gt_fgINT32);
}
void flgr_vector_cmp_gt_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_gt_fgINT64);
}
void flgr_vector_cmp_gt_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_gt_fgFLOAT32);
}
void flgr_vector_cmp_gt_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_gt_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compare two vectors and store results in a vector
 *
 *  dest[k] = (vct1[k] > vct2[k]) ? MAX_TYPE : 0
 *
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_cmp_gt(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type, flgr_vector_cmp_gt, vctdest, vct1, vct2);
}







void flgr_vector_cmp_lt_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_lt_fgBIT);
}
void flgr_vector_cmp_lt_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_lt_fgUINT8);
}
void flgr_vector_cmp_lt_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_lt_fgUINT16);
}
void flgr_vector_cmp_lt_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_lt_fgUINT32);
}
void flgr_vector_cmp_lt_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_lt_fgUINT64);
}
void flgr_vector_cmp_lt_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_lt_fgINT8);
}
void flgr_vector_cmp_lt_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_lt_fgINT16);
}
void flgr_vector_cmp_lt_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_lt_fgINT32);
}
void flgr_vector_cmp_lt_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_lt_fgINT64);
}
void flgr_vector_cmp_lt_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_lt_fgFLOAT32);
}
void flgr_vector_cmp_lt_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_lt_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compare two vectors and store results in a vector
 *
 *  dest[k] = (vct1[k] < vct2[k]) ? MAX_TYPE : 0
 *
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_cmp_lt(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type, flgr_vector_cmp_lt, vctdest, vct1, vct2);
}







void flgr_vector_cmp_le_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_le_fgBIT);
}
void flgr_vector_cmp_le_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_le_fgUINT8);
}
void flgr_vector_cmp_le_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_le_fgUINT16);
}
void flgr_vector_cmp_le_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_le_fgUINT32);
}
void flgr_vector_cmp_le_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_le_fgUINT64);
}
void flgr_vector_cmp_le_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_le_fgINT8);
}
void flgr_vector_cmp_le_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_le_fgINT16);
}
void flgr_vector_cmp_le_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_le_fgINT32);
}
void flgr_vector_cmp_le_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_le_fgINT64);
}
void flgr_vector_cmp_le_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_le_fgFLOAT32);
}
void flgr_vector_cmp_le_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_le_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compare two vectors and store resules in a vector
 *
 *  dest[k] = (vct1[k] <= vct2[k]) ? MAX_TYPE : 0
 *
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_cmp_le(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type, flgr_vector_cmp_le, vctdest, vct1, vct2);
}






void flgr_vector_cmp_ge_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgBIT,flgr_defop_ge_fgBIT);
}
void flgr_vector_cmp_ge_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT8,flgr_defop_ge_fgUINT8);
}
void flgr_vector_cmp_ge_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT16,flgr_defop_ge_fgUINT16);
}
void flgr_vector_cmp_ge_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT32,flgr_defop_ge_fgUINT32);
}
void flgr_vector_cmp_ge_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgUINT64,flgr_defop_ge_fgUINT64);
}
void flgr_vector_cmp_ge_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT8,flgr_defop_ge_fgINT8);
}
void flgr_vector_cmp_ge_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT16,flgr_defop_ge_fgINT16);
}
void flgr_vector_cmp_ge_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT32,flgr_defop_ge_fgINT32);
}
void flgr_vector_cmp_ge_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgINT64,flgr_defop_ge_fgINT64);
}
void flgr_vector_cmp_ge_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT32,flgr_defop_ge_fgFLOAT32);
}
void flgr_vector_cmp_ge_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  FLGR_MACRO_VECTOR_DIADIC_OP(fgFLOAT64,flgr_defop_ge_fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Compare two vectors and store resuges in a vector
 *
 *  dest[k] = (vct1[k] >= vct2[k]) ? MAX_TYPE : 0
 *
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @param vct2 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_cmp_ge(FLGR_Vector *vctdest, FLGR_Vector *vct1, FLGR_Vector *vct2) {
  
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vct2);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type, flgr_vector_cmp_ge, vctdest, vct1, vct2);
}






////////////////////////////////////////////////////////////////////////////
// Macro for conditionals Moves
////////////////////////////////////////////////////////////////////////////
#define FLGR_MACRO_VECTOR_CMOVE(dtype)					\
  int k;								\
  int spp = vctdest->spp;						\
  dtype *pcmp = (dtype*) vctcmp->array;					\
  dtype *p1 = (dtype*) vct1->array;					\
  dtype *pdest = (dtype*) vctdest->array;				\
									\
  for(k=0 ; k<spp ; k++) {						\
    pdest[k] = flgr_defop_cmove_##dtype(pcmp[k], p1[k], pdest[k]);	\
  }									\
  return


void flgr_vector_cmove_fgBIT(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgBIT);
}
void flgr_vector_cmove_fgUINT8(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgUINT8);
}
void flgr_vector_cmove_fgUINT16(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgUINT16);
}
void flgr_vector_cmove_fgUINT32(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgUINT32);
}
void flgr_vector_cmove_fgUINT64(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgUINT64);
}
void flgr_vector_cmove_fgINT8(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgINT8);
}
void flgr_vector_cmove_fgINT16(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgINT16);
}
void flgr_vector_cmove_fgINT32(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgINT32);
}
void flgr_vector_cmove_fgINT64(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgINT64);
}
void flgr_vector_cmove_fgFLOAT32(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgFLOAT32);
}
void flgr_vector_cmove_fgFLOAT64(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  FLGR_MACRO_VECTOR_CMOVE(fgFLOAT64);
}
////////////////////////////////////////////////////////////////////////////
/*! Conditional Copy of element regarding flags
 *
 *  dest[k] = (cmp[k] != 0) ? vct1[k] : dest[k]
 *
 *  @param vctdest : pointer to FLGR_Vector
 *  @param vctcmp : pointer to FLGR_Vector
 *  @param vct1 : pointer to FLGR_Vector
 *  @returns FLGR_RET_OK, ...
 */
//////////////////////////////////////////////////////////////////
FLGR_Ret flgr_vector_cmove(FLGR_Vector *vctdest, FLGR_Vector *vctcmp, FLGR_Vector *vct1) {
  
  FLGR_Ret ret;

  FLGR_DECLARE_FUNCTION;

  ret = flgr_vector_is_same_type(vct1,vctcmp);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_type(vctdest,vctcmp);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector type different !\n");
    return FLGR_RET_TYPE_DIFFERENT;
  }

  ret = flgr_vector_is_same_spp(vct1,vctcmp);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }

  ret = flgr_vector_is_same_spp(vctdest,vctcmp);
  if(ret != FLGR_RET_OK) {
    POST_ERROR("Vector SPP different !\n");
    return FLGR_RET_UNDEFINED_ERROR;
  }


  FLGR_FULL_PROCEDURE_DISPATCH(vctdest->type, flgr_vector_cmove, vctdest, vctcmp, vct1);
}



//! @}
